import qualified Data.ByteString.Lazy.Char8 as L8
import qualified Data.ByteString.Char8 as S8
import qualified Data.Map as M
-import qualified System.FilePath.ByteString as P
{- A CredPair can be stored in a file, or in the environment, or
- in a remote's configuration. -}
data CredPairStorage = CredPairStorage
- { credPairFile :: FilePath
+ { credPairFile :: OsPath
, credPairEnvironment :: (String, String)
, credPairRemoteField :: RemoteConfigField
}
{- Stores the creds in a file inside gitAnnexCredsDir that only the user
- can read. -}
-writeCreds :: Creds -> FilePath -> Annex ()
+writeCreds :: Creds -> OsPath -> Annex ()
writeCreds creds file = do
d <- fromRepo gitAnnexCredsDir
createAnnexDirectory d
- liftIO $ writeFileProtected (d P.</> toRawFilePath file) creds
+ liftIO $ writeFileProtected (d </> file) creds
-readCreds :: FilePath -> Annex (Maybe Creds)
+readCreds :: OsPath -> Annex (Maybe Creds)
readCreds f = do
- f' <- toOsPath . toRawFilePath <$> credsFile f
+ f' <- credsFile f
liftIO $ catchMaybeIO $ decodeBS . S8.unlines . fileLines'
<$> F.readFile' f'
-credsFile :: FilePath -> Annex FilePath
+credsFile :: OsPath -> Annex OsPath
credsFile basefile = do
- d <- fromRawFilePath <$> fromRepo gitAnnexCredsDir
+ d <- fromRepo gitAnnexCredsDir
return $ d </> basefile
encodeCredPair :: CredPair -> Creds
l:p:[] -> Just (l, p)
_ -> Nothing
-removeCreds :: FilePath -> Annex ()
+removeCreds :: OsPath -> Annex ()
removeCreds file = do
d <- fromRepo gitAnnexCredsDir
- liftIO $ removeWhenExistsWith R.removeLink (d P.</> toRawFilePath file)
+ liftIO $ removeWhenExistsWith R.removeLink (fromOsPath (d </> file))
includeCredsInfo :: ParsedRemoteConfig -> CredPairStorage -> [(String, String)] -> Annex [(String, String)]
includeCredsInfo pc@(ParsedRemoteConfig cm _) storage info = do
import qualified Data.ByteString.Char8 as B8
import System.Random
import Control.Concurrent
-import qualified System.FilePath.ByteString as P
#endif
benchmarkDbs :: CriterionMode -> Integer -> Annex ()
#ifdef WITH_BENCHMARK
-benchmarkDbs mode n = withTmpDirIn "." (toOsPath "benchmark") $ \tmpdir -> do
- db <- benchDb (toRawFilePath tmpdir) n
+benchmarkDbs mode n = withTmpDirIn (literalOsPath ".") (literalOsPath "benchmark") $ \tmpdir -> do
+ db <- benchDb tmpdir n
liftIO $ runMode mode
[ bgroup "keys database"
[ getAssociatedFilesHitBench db
}
fileN :: Integer -> TopFilePath
-fileN n = asTopFilePath (toRawFilePath ("file" ++ show n))
+fileN n = asTopFilePath (toOsPath ("file" ++ show n))
keyMiss :: Key
keyMiss = keyN 0 -- 0 is never stored
data BenchDb = BenchDb H.DbQueue Integer (MVar Integer)
-benchDb :: RawFilePath -> Integer -> Annex BenchDb
+benchDb :: OsPath -> Integer -> Annex BenchDb
benchDb tmpdir num = do
liftIO $ putStrLn $ "setting up database with " ++ show num ++ " items"
initDb db SQL.createTables
mv <- liftIO $ newMVar 1
return (BenchDb h num mv)
where
- db = tmpdir P.</> toRawFilePath (show num </> "db")
+ db = tmpdir </> toOsPath (show num) </> literalOsPath "db"
#endif /* WITH_BENCHMARK */
import Database.Persist.Sqlite
import Lens.Micro
import qualified Data.Text as T
-import qualified System.FilePath.ByteString as P
{- Ensures that the database is freshly initialized. Deletes any
- existing database. Pass the migration action for the database.
- file causes Sqlite to always use the same permissions for additional
- files it writes later on
-}
-initDb :: P.RawFilePath -> SqlPersistM () -> Annex ()
+initDb :: OsPath -> SqlPersistM () -> Annex ()
initDb db migration = do
- let dbdir = P.takeDirectory db
- let tmpdbdir = dbdir <> ".tmp"
- let tmpdb = tmpdbdir P.</> "db"
- let tmpdb' = T.pack (fromRawFilePath tmpdb)
+ let dbdir = takeDirectory db
+ let tmpdbdir = dbdir <> literalOsPath ".tmp"
+ let tmpdb = tmpdbdir </> literalOsPath "db"
+ let tmpdb' = fromOsPath tmpdb
createAnnexDirectory tmpdbdir
#if MIN_VERSION_persistent_sqlite(2,13,3)
- liftIO $ runSqliteInfo' tmpdb (enableWAL tmpdb') migration
+ liftIO $ runSqliteInfo' tmpdb' (enableWAL tmpdb') migration
#else
liftIO $ runSqliteInfo (enableWAL tmpdb') migration
#endif
setAnnexDirPerm tmpdbdir
-- Work around sqlite bug that prevents it from honoring
-- less restrictive umasks.
- liftIO $ R.setFileMode tmpdb =<< defaultFileMode
+ liftIO $ R.setFileMode tmpdb' =<< defaultFileMode
setAnnexFilePerm tmpdb
liftIO $ do
- void $ tryIO $ removeDirectoryRecursive (fromRawFilePath dbdir)
- R.rename tmpdbdir dbdir
+ void $ tryIO $ removeDirectoryRecursive dbdir
+ R.rename (fromOsPath tmpdbdir) (fromOsPath dbdir)
{- Make sure that the database uses WAL mode, to prevent readers
- from blocking writers, and prevent a writer from blocking readers.
-
- Note that once WAL mode is enabled, it will persist whenever the
- database is opened. -}
-enableWAL :: T.Text -> SqliteConnectionInfo
+enableWAL :: RawFilePath -> SqliteConnectionInfo
enableWAL db = over walEnabled (const True) $
- mkSqliteConnectionInfo db
+ mkSqliteConnectionInfo (T.pack (fromRawFilePath db))
- Licensed under the GNU AGPL version 3 or higher.
-}
+{-# LANGUAGE OverloadedStrings #-}
+
module P2P.Address where
import qualified Annex
addrs <- loadP2PAddresses
unless (addr `elem` addrs) $ do
let s = unlines $ map formatP2PAddress (addr:addrs)
- let tmpnam = p2pAddressCredsFile ++ ".new"
+ let tmpnam = p2pAddressCredsFile <> literalOsPath ".new"
writeCreds s tmpnam
tmpf <- credsFile tmpnam
destf <- credsFile p2pAddressCredsFile
-- This may be run by root, so make the creds file
-- and directory have the same owner and group as
-- the git repository directory has.
- st <- liftIO . R.getFileStatus . toRawFilePath
- =<< Annex.fromRepo repoLocation
- let fixowner f = R.setOwnerAndGroup (toRawFilePath f) (fileOwner st) (fileGroup st)
+ st <- liftIO . R.getFileStatus . fromOsPath
+ =<< Annex.fromRepo repoPath
+ let fixowner f = R.setOwnerAndGroup (fromOsPath f) (fileOwner st) (fileGroup st)
liftIO $ do
fixowner tmpf
fixowner (takeDirectory tmpf)
fixowner (takeDirectory (takeDirectory tmpf))
renameFile tmpf destf
-p2pAddressCredsFile :: FilePath
-p2pAddressCredsFile = "p2paddrs"
+p2pAddressCredsFile :: OsPath
+p2pAddressCredsFile = literalOsPath "p2paddrs"
torAppName :: AppName
torAppName = "tor-annex"
- Licensed under the GNU AGPL version 3 or higher.
-}
+{-# LANGUAGE OverloadedStrings #-}
+
module P2P.Auth where
import Annex.Common
let d = unlines $ map (T.unpack . fromAuthToken) (t:ts)
writeCreds d p2pAuthCredsFile
-p2pAuthCredsFile :: FilePath
-p2pAuthCredsFile = "p2pauth"
+p2pAuthCredsFile :: OsPath
+p2pAuthCredsFile = literalOsPath "p2pauth"
-- | Loads the AuthToken to use when connecting with a given P2P address.
--
(T.unpack $ fromAuthToken t)
(addressCredsFile addr)
-addressCredsFile :: P2PAddress -> FilePath
+addressCredsFile :: P2PAddress -> OsPath
-- We can omit the port and just use the onion address for the creds file,
-- because any given tor hidden service runs on a single port and has a
-- unique onion address.
-addressCredsFile (TorAnnex (OnionAddress onionaddr) _port) = onionaddr
+addressCredsFile (TorAnnex (OnionAddress onionaddr) _port) =
+ toOsPath onionaddr
creds :: UUID -> CredPairStorage
creds u = CredPairStorage
- { credPairFile = fromUUID u
+ { credPairFile = literalOsPath (fromUUID u)
, credPairEnvironment = ("AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY")
, credPairRemoteField = s3credsField
}
projects / git-annex.git / commitdiff